package controllers

import (
	"stacks/models"
	"stacks/services"
	"stacks/utils"

	"github.com/gin-gonic/gin"
)

// RoleController 角色控制器
type RoleController struct {
	roleService *services.RoleService
}

// NewRoleController 创建角色控制器实例
func NewRoleController() *RoleController {
	return &RoleController{
		roleService: services.NewRoleService(),
	}
}

// GetRoleList 获取角色列表
// @Summary 获取角色列表
// @Description 获取角色列表（需要认证）
// @Tags 角色管理
// @Accept json
// @Produce json
// @Security ApiKeyAuth
// @Param tenantId query int true "租户ID"
// @Param page query int false "页码" default(1)
// @Param pageSize query int false "每页数量" default(10)
// @Success 200 {object} map[string]interface{} "角色列表"
// @Failure 401 {object} map[string]interface{} "未授权"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /admin/roles [get]
func (c *RoleController) GetRoleList(ctx *gin.Context) {
	parser := utils.NewParamParser(ctx)
	tenantID := parser.Uint("tenantId")
	page := parser.Int("page")
	pageSize := parser.Int("pageSize")

	if page < 1 {
		page = 1
	}
	if pageSize < 1 || pageSize > 100 {
		pageSize = 10
	}

	roles, total, err := c.roleService.GetRoleList(tenantID, page, pageSize)
	if err != nil {
		utils.InternalError(ctx, "获取角色列表失败")
		return
	}

	utils.Success(ctx, gin.H{
		"list":  roles,
		"total": total,
		"page":  page,
		"size":  pageSize,
	})
}

// GetRoleByID 根据ID获取角色
func (c *RoleController) GetRoleByID(ctx *gin.Context) {
	parser := utils.NewParamParser(ctx)
	id := parser.PathUint("id")
	tenantID := parser.Uint("tenantId")

	role, err := c.roleService.GetRoleByID(id, tenantID)
	if err != nil {
		utils.NotFound(ctx, "角色不存在")
		return
	}

	utils.Success(ctx, role)
}

// CreateRole 创建角色
func (c *RoleController) CreateRole(ctx *gin.Context) {
	parser := utils.NewParamParser(ctx)
	var role models.SysRole
	parser.Bind(&role)

	err := c.roleService.CreateRole(&role)
	if err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}

	utils.Success(ctx, "创建成功")
}

// UpdateRole 更新角色
func (c *RoleController) UpdateRole(ctx *gin.Context) {
	parser := utils.NewParamParser(ctx)
	id := parser.PathUint("id")
	tenantID := parser.Uint("tenantId")

	var updates map[string]interface{}
	parser.Bind(&updates)

	err := c.roleService.UpdateRole(id, tenantID, updates)
	if err != nil {
		return
	}
	utils.Success(ctx, "更新成功")
}

// DeleteRole 删除角色
func (c *RoleController) DeleteRole(ctx *gin.Context) {
	parser := utils.NewParamParser(ctx)
	id := parser.PathUint("id")
	tenantID := parser.Uint("tenantId")

	err := c.roleService.DeleteRole(id, tenantID)
	if err != nil {
		return
	}

	utils.Success(ctx, "删除成功")
}

// AssignPermissionsRequest 分配权限请求
type AssignPermissionsRequest struct {
	PermissionIDs []uint `json:"permissionIds" binding:"required"`
}

// AssignPermissions 分配权限给角色
func (c *RoleController) AssignPermissions(ctx *gin.Context) {
	parser := utils.NewParamParser(ctx)
	id := parser.PathUint("id")
	tenantID := parser.Uint("tenantId")

	var req AssignPermissionsRequest
	parser.Bind(&req)

	err := c.roleService.AssignPermissions(id, tenantID, req.PermissionIDs)
	if err != nil {
		return
	}

	utils.Success(ctx, "权限分配成功")
}
